Como relatar janelas deslizantes com uma duração fixa em segundos de forma eficiente

Acho que você quis dizer incremento com base em "Para cada janela de duração de 2 segundos começando em um segundo limite" e não sobreposição. Para intervalos de dois segundos, é o mesmo, mas como você deseja variar a duração, uma sobreposição de um segundo seria 0-3, 2-5, 4-7, mas o incremento significaria 0-3, 1-4, 2- 5 No entanto, foi interessante descobrir soluções para ambos, por precaução.
Supondo que L seja classificado e todos os elementos sejam positivos e todos os segundos intervalos iniciem com inteiros, podemos usar este método:
importar matemática
das coleções importar defaultdict
L = [0,10218048, 1,20851996, 1,46800021, 1,73429061, 2,71525848,
3,14781922, 3,63637958, 5,11147358, 5,97497864, 6,35469013,
6,80623747, 6,99571917, 7,65215123, 7,86108352, 8,52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
my_ranges = defaultdict (lista)
intervalo_largura = 2
para x em L:
Upper_bound = math.ceil (x)
limite_inferior = limite_maior - largura_intervalo
limite_inferior = max (0, limite_inferior)
para y no intervalo (limite_inferior, limite_maior):
my_ranges [y] .append (x)
para um em classificado (my_ranges):
imprimir (minhas_faixas [a])
Não sei se você deseja ver se há intervalos vazios. Mas o defaultdict imprime intervalos vazios se você quiser também. Use esta linha em vez de "para um classificado":
para um intervalo (min (my_range), max (my_range) + 1):
Se você quiser os intervalos de 0-3, 2-5, 4-7, isso funciona:
importar matemática
das coleções importar defaultdict
L = [0,10218048, 1,20851996, 1,46800021, 1,73429061, 2,71525848,
3,14781922, 3,63637958, 5,11147358, 5,97497864, 6,35469013,
6,80623747, 6,99571917, 7,65215123, 7,86108352, 8,52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
largura_de_intervalo = 2
my_ranges_2 = defaultdict (lista)
para x em L:
definitivamente_em = (x // (largura_intervalo - 1)) * (largura_intervalo - 1) # múltiplo mais baixo de largura_intervalo abaixo de x sempre estará em
#print ("Adicionando", x, "a", definitivamente_in)
my_ranges_2 [definitivamente_em] .append (x)
se x  = 0: # por exemplo, se x for 2,3 e tivermos 0,3 2,5 etc. ... precisamos capturar este caso duplicado. Estou assumindo que os comprimentos das janelas são inteiros e, se não, temos muito mais a fazer, porque o número pode estar em mais de uma matriz. Talvez pudéssemos ter um loop while, incrementando por (intervalo_ largura - 1)
#print ("++ Adicionando", x, "a", definitivamente_em - largura_de_intervalo + 1)
my_ranges_2 [definitivamente_em - intervalo_largura + 1] .append (x)
para um em classificado (my_ranges_2):
imprimir (a, my_ranges_2 [a])
# imprimir (my_ranges_2 [a])
Suspeito que esqueci alguns detalhes, mas espero que você possa alterar interval_width conforme necessário para ter certeza de que meu código está fazendo o que você esperava e me diga exatamente o que você precisa.
|
Uma possível solução que posso propor é "eficiente" em certo sentido, que itera apenas uma vez por meio dos dados de entrada e não tem dependências. O custo, é claro, é que ele é escrito em python puro (pode haver código mais otimizado) e que introduz mais variáveis ​​de rastreamento para evitar a reiteração (e, portanto, é menos python).
def slide_window (dados, duração, início = 0, sobreposição = 1):
resultado = []
data_idx = 0
result_idx = 0
superior = início + duração
inferior = início
next_lower = superior - sobreposição
# auxiliar interno para preencher listas internas vazias até nosso ponto de inserção e inserir
def pad_and_append (at):
enquanto len (resultado) <= em:
result.append ([])
resultado [at] .append (dados [data_idx])
# iterar por meio de dados de entrada
enquanto data_idx  a:
se x  = l [0]) & (L  = i) & (L